package com.example.designpatterns.chain;

/**
 * 责任链模式演示类
 */
public class ChainPatternDemo {
    public static void main(String[] args) {
        System.out.println("===== 责任链模式演示 =====\n");
        
        // 演示基于请求类型的责任链
        demonstrateTypeBasedChain();
        
        System.out.println("\n===== 分隔线 =====\n");
        
        // 演示基于请求优先级的责任链
        demonstratePriorityBasedChain();
    }
    
    /**
     * 演示基于请求类型的责任链
     */
    private static void demonstrateTypeBasedChain() {
        System.out.println("===== 基于请求类型的责任链 =====");
        
        // 创建处理者
        Handler infoHandler = new InfoHandler();
        Handler debugHandler = new DebugHandler();
        Handler warningHandler = new WarningHandler();
        Handler errorHandler = new ErrorHandler();
        Handler criticalHandler = new CriticalHandler();
        
        // 构建责任链
        System.out.println("构建责任链: 信息处理器 -> 调试处理器 -> 警告处理器 -> 错误处理器 -> 严重错误处理器");
        infoHandler.setNext(debugHandler)
                   .setNext(warningHandler)
                   .setNext(errorHandler)
                   .setNext(criticalHandler);
        
        // 创建不同类型的请求
        Request infoRequest = new Request(Request.RequestType.INFO, "系统启动成功", 1);
        Request debugRequest = new Request(Request.RequestType.DEBUG, "变量x的值为42", 2);
        Request warningRequest = new Request(Request.RequestType.WARNING, "磁盘空间不足", 4);
        Request errorRequest = new Request(Request.RequestType.ERROR, "数据库连接失败", 7);
        Request criticalRequest = new Request(Request.RequestType.CRITICAL, "主服务器宕机", 10);
        
        // 使用责任链处理请求
        System.out.println("\n处理信息请求:");
        infoHandler.handleRequest(infoRequest);
        
        System.out.println("\n处理调试请求:");
        infoHandler.handleRequest(debugRequest);
        
        System.out.println("\n处理警告请求:");
        infoHandler.handleRequest(warningRequest);
        
        System.out.println("\n处理错误请求:");
        infoHandler.handleRequest(errorRequest);
        
        System.out.println("\n处理严重错误请求:");
        infoHandler.handleRequest(criticalRequest);
        
        // 创建一个未知类型的请求（通过将enum扩展为其他类型）
        // 这里我们模拟一个未知类型，实际上是复用现有类型
        Request unknownRequest = new Request(Request.RequestType.INFO, "这是一个未知类型的请求", 5) {
            @Override
            public RequestType getType() {
                // 模拟一个未知的请求类型
                return null;
            }
        };
        
        System.out.println("\n处理未知类型的请求:");
        infoHandler.handleRequest(unknownRequest);
    }
    
    /**
     * 演示基于请求优先级的责任链
     */
    private static void demonstratePriorityBasedChain() {
        System.out.println("===== 基于请求优先级的责任链 =====");
        
        // 创建基于优先级的处理者
        Handler lowPriorityHandler = new PriorityHandler("低优先级处理器", 1, 3);
        Handler mediumPriorityHandler = new PriorityHandler("中优先级处理器", 4, 7);
        Handler highPriorityHandler = new PriorityHandler("高优先级处理器", 8, 10);
        
        // 构建责任链
        System.out.println("构建责任链: 低优先级处理器 -> 中优先级处理器 -> 高优先级处理器");
        lowPriorityHandler.setNext(mediumPriorityHandler)
                          .setNext(highPriorityHandler);
        
        // 创建不同优先级的请求
        Request lowPriorityRequest = new Request(Request.RequestType.INFO, "日常信息记录", 2);
        Request mediumPriorityRequest = new Request(Request.RequestType.WARNING, "系统性能下降", 5);
        Request highPriorityRequest = new Request(Request.RequestType.ERROR, "服务不可用", 9);
        Request outOfRangeRequest = new Request(Request.RequestType.DEBUG, "超出范围的请求", 11);
        
        // 使用责任链处理请求
        System.out.println("\n处理低优先级请求:");
        lowPriorityHandler.handleRequest(lowPriorityRequest);
        
        System.out.println("\n处理中优先级请求:");
        lowPriorityHandler.handleRequest(mediumPriorityRequest);
        
        System.out.println("\n处理高优先级请求:");
        lowPriorityHandler.handleRequest(highPriorityRequest);
        
        System.out.println("\n处理超出范围的请求:");
        lowPriorityHandler.handleRequest(outOfRangeRequest);
    }
} 